package com.itzjc.service.impl;

import com.itzjc.dao.ProjectMapper;
import com.itzjc.dao2.DataMapper2;
import com.itzjc.domain.entity.*;
import com.itzjc.domain.pojo.*;
import com.itzjc.service.DataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.util.*;

/**
 * 由于都是查询，所以查出的数据遗漏的没有影响，所以就没用启动事务
 *
 * @className: DataServiceImpl
 * @date: 2021-06-28 20:56
 **/
@Service
public class DataServiceImpl implements DataService {
    @Autowired(required = false)
    private DataMapper2 dataMapper2;
    @Autowired(required = false)
    private ProjectMapper dataMapper1;



    @Override
    public List<TableData> getAllInitDataByToken() {
        //从关系表中获取除值以外的其他信息
        List<AllCurrentData> allCurrentData = dataMapper2.getAllInitDataExceptValue();
        //从数据表中获取最新的数据信息
        List<Double> value = dataMapper2.getAllInitValue();
        for (int i = 0; i < allCurrentData.size(); i++) {
            allCurrentData.get(i).setValue(value.get(i));
        }
        List<TableData> tableDataList = new ArrayList<>();

        for (AllCurrentData allCurrentDatum : allCurrentData) {
            TableData tableData = new TableData();
            tableData.setPlane("测区" + allCurrentDatum.getLocation());
            tableData.setSectionID("测站" + allCurrentDatum.getSectionID());
            tableData.setSid(allCurrentDatum.getSID());
            //这里抽取了根据获取的数值判断类型的方法
            judgeStype(allCurrentDatum, tableData);
            tableData.setUnit(allCurrentDatum.getUnit());

            //设置值的时候同样存在小数点的问题
            Double value1 = allCurrentDatum.getValue();
            BigDecimal bigDecimal = new BigDecimal(value1);
            double value2 = bigDecimal.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
            tableData.setValue(value2);


            tableData.setRatio(1.0);
            tableData.setPosX(allCurrentDatum.getPosX());
            tableData.setPosY(allCurrentDatum.getPosY());
            tableData.setPosZ(allCurrentDatum.getPosZ());
            //保留小数，在进行之前做非空判断
            if (null != allCurrentDatum.getLmax() && null != allCurrentDatum.getLmin()) {
                double f = allCurrentDatum.getLmax();
                double f1 = allCurrentDatum.getLmin();
                BigDecimal b = new BigDecimal(f);
                BigDecimal b1 = new BigDecimal(f1);
                double f2 = b.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
                double f3 = b1.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
                tableData.setLmin(f2);
                tableData.setLmax(f3);

            }
            tableDataList.add(tableData);
        }
        return tableDataList;
    }

    @Override
    public TableBaseInfo getBaseInfoByToken() {
        BigInteger dataTime = dataMapper2.getBaseTime();
        Integer planesNumber = dataMapper2.getBasePlanesNumber();
        Integer sitesNumber = dataMapper2.getBaseSitesNumber();
        Integer pointsNumber = dataMapper2.getBasePointsNumber();

        TableBaseInfo tableBaseInfo = new TableBaseInfo();
        //转换数据格式
        long longValue = dataTime.longValue();
        //倒推标准时间所需要减去的时间
        long baseLongValue = 404467200000L;
        Date date = new Date(longValue - baseLongValue);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = simpleDateFormat.format(date);
        tableBaseInfo.setTime(time);
        tableBaseInfo.setPlanesNumber(planesNumber);
        tableBaseInfo.setSitesNumber(sitesNumber);
        tableBaseInfo.setPointsNumber(pointsNumber);
        return tableBaseInfo;
    }

    @Override
    public TitleInfo gettableTitleByToke() {
        List<Integer> planes = dataMapper2.gettableTitleOfPlanes();
        List<Integer> sites = dataMapper2.gettableTitleOfSites();
        List<Integer> types = dataMapper2.gettableTitleOfTypes();
        List<TableTileOfPlanes> tableTileOfPlanes = new ArrayList<>();
        List<TableTileOfSites> tableTileOfSites = new ArrayList<>();
        List<TableTileOfTypes> tableTileOfTypes = new ArrayList<>();


        for (Integer plane : planes) {
            TableTileOfPlanes tableTileOfPlanes1 = new TableTileOfPlanes();
            tableTileOfPlanes1.setText("测区" + plane);
            tableTileOfPlanes1.setValue("测区" + plane);
            tableTileOfPlanes.add(tableTileOfPlanes1);
        }
        for (Integer site : sites) {
            TableTileOfSites tableTileOfSites1 = new TableTileOfSites();
            tableTileOfSites1.setText("测站" + site);
            tableTileOfSites1.setValue("测站" + site);
            tableTileOfSites.add(tableTileOfSites1);
        }
        for (Integer type : types) {
            TableTileOfTypes tableTileOfTypes1 = new TableTileOfTypes();
            switch (type) {
                case 1:
                    tableTileOfTypes1.setText("应力");
                    tableTileOfTypes1.setValue("应力");
                    break;
                case 2:
                    tableTileOfTypes1.setText("位移");
                    tableTileOfTypes1.setValue("位移");
                    break;
                case 3:
                    tableTileOfTypes1.setText("挠度");
                    tableTileOfTypes1.setValue("挠度");
                    break;
                case 4:
                    tableTileOfTypes1.setText("温度");
                    tableTileOfTypes1.setValue("温度");
                    break;
                case 5:
                    tableTileOfTypes1.setText("应变");
                    tableTileOfTypes1.setValue("应变");
                    break;
                default:
                    tableTileOfTypes1.setText("其他");
                    tableTileOfTypes1.setValue("其他");
            }
            tableTileOfTypes.add(tableTileOfTypes1);
        }

        TitleInfo titleInfo = new TitleInfo();
        titleInfo.setPlanes(tableTileOfPlanes);
        titleInfo.setSites(tableTileOfSites);
        titleInfo.setTypes(tableTileOfTypes);
        return titleInfo;
    }

    @Override
    public List<PlaneData> getAllGraphDataByToken() {
        List<PlaneData> allGraphData = new ArrayList<>();
        BigInteger dataTime = dataMapper2.getBaseTime();
        List<Integer> planes = dataMapper2.gettableTitleOfPlanes();
        //List<Integer> sites = dataMapper2.gettableTitleOfSites();对于测站需要对应起来，我们要找对应关系，所以要发请求而不是这种统一获取

        //获取传感器的全部对应关系
        //从关系表中获取除值以外的部分信息，主要就是sid、stype、unit这些，便于后续根据sid直接在这个索引中找，而且合理的数据都是排序好的
        //所以后续直接根据索引就可以找到了
        List<AllCurrentData> allCurrentData = dataMapper2.getAllInitDataExceptValue();

        //这里是把数据处理封装一下，因为上面获取的数据类型没有转化成中文的，这里就统一封装处理一下
        List<TableData> tableDataList = new ArrayList<>();

        for (AllCurrentData allCurrentDatum : allCurrentData) {
            TableData tableData = new TableData();
            tableData.setSid(allCurrentDatum.getSID());
            //这里抽取了根据获取的数值判断类型的方法
            judgeStype(allCurrentDatum, tableData);
            tableData.setUnit(allCurrentDatum.getUnit());
            tableDataList.add(tableData);
        }


        //根据时间获取昨天到现在的数据，所以要计算现在的时间并且传过去
        Date currentDate = new Date();
        LocalDateTime midnight = LocalDateTime.ofInstant(currentDate.toInstant(),
                ZoneId.systemDefault()).plusDays(-1).withHour(0).withMinute(0)
                .withSecond(0).withNano(0);
        long time2 = midnight.toInstant(ZoneOffset.of("+8")).toEpochMilli();
        //倒推标准时间所需要减去的时间
        long baseLongValue = 404467200000L;
        //数据库的标准时间
        long realTime = baseLongValue + time2;
        List<InitGrapData> initTimingGraphData = dataMapper2.getTimingInitGraphData(realTime);

        //写入时间步长,这里不要乱写，还是计算一下比较好,然后尽量不要在循环中写sql语句，这句完全可以移出去
        //注意，这里不是每次都有最新数据的，有时候有些传感器没有数据更新，数据还停留在昨天
        BigInteger latestTime = dataMapper2.getLatestTime(realTime);
        BigInteger nowTime = dataMapper2.getNowTime(realTime);
        if (null != latestTime || null != nowTime) {
            Integer nowTotalTimes = dataMapper2.getTotalTimes(realTime);
            long timeStamp = (nowTime.longValue() - latestTime.longValue()) / nowTotalTimes;
            int intTimeStamp = (int) timeStamp;

            //整理数据成前端需要的格式输出给前端
            for (Integer plane : planes) {
                PlaneData planeData1 = new PlaneData();
                //写入ID
                planeData1.setSectionId(plane);
                //写入时间
                long longValue = dataTime.longValue();
                Date date = new Date(longValue - baseLongValue);
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String time = simpleDateFormat.format(date);
                planeData1.setCurrentTime(time);
                //写入名称
                planeData1.setName("测区" + plane);

                //写入计算出的步长
                planeData1.setTimeStamp(String.valueOf(intTimeStamp));

                //这里计算出时间步长以后，还需要计算一个东西，就是计算在此步长下，两天一共需要多少个点
                //计算出的这个点的个数就作为数组的固定长度，后面需要统一补充长度的时候用得到
                long twoDays = 60000 * 60 * 24 * 2;
                int selfMakeTotalTimes = (int) (twoDays / timeStamp);

                //图片啥的现在还没有，就不写了

                //写入对应的测站，但是测站需要根据这里的测区选取来重新获取,所以这里就写了查询的语句
//            List<Integer> sites = dataMapper2.getSectionIdViaSectionIDAndLocation(plane);

                //其实还有一个思路就是自己遍历一遍allCurrentData,如果location对应上了就把SectionID存入到hashSet中,就不用上面的查询语句了
                Set<Integer> sitesSet = new HashSet<>();
                for (AllCurrentData allCurrentDatum : allCurrentData) {
                    if (Integer.parseInt(allCurrentDatum.getLocation()) == plane) {

                        sitesSet.add(allCurrentDatum.getSectionID());
                    }
                }
                //转成lsit这样方便后续获取值
                List<Integer> sites = new ArrayList<>(sitesSet);


                List<SiteData> siteDataList = new ArrayList<>();
                for (Integer site : sites) {
                    SiteData siteData1 = new SiteData();
                    //写入名称
                    siteData1.setName("测站" + site);
                    //写入设备信息,这里也是先直接写
                    siteData1.setMachineInfo("此设备生产日期为：2016-12-30");
                    //此时有了sectionID和location，需要查出所有对应的sensorID
                    List<PointData> pointData = new ArrayList<>();

//                List<Integer> sensors = dataMapper2.getSensorIdViaSectionIDAndLocation(plane, site);

                    //还是一样的，不要去数据库中查，自己遍历就行了，同上面的遍历出sites的方法
                    Set<Integer> sensorSet = new HashSet<>();
                    for (AllCurrentData allCurrentDatum : allCurrentData) {
                        if (Integer.parseInt(allCurrentDatum.getLocation()) == plane && allCurrentDatum.getSectionID().equals(site)) {
                            sensorSet.add(allCurrentDatum.getSID());
                        }
                    }
                    List<Integer> sensors = new ArrayList<>(sensorSet);
                    //这里得到的list没有排序，排下序比较好
                    Collections.sort(sensors);

                    for (Integer sensor : sensors) {
                        //根据查出来的ID个数进行遍历
                        PointData pointData1 = new PointData();
                        //写入ID
                        pointData1.setSid(sensor);
                        //写入名称
                        pointData1.setName("传感器" + sensor + "号");
                        //写入类型，这里应该肯定不能发请求，一定要遍历的方式来，
                        // 比如我们知道了这里的ID，我们可以直接通过获取整体的数据排序好的索引来获取，就是前面说的思路
                        pointData1.setType(tableDataList.get(sensor - 1).getStype());
                        pointData1.setUnit(tableDataList.get(sensor - 1).getUnit());


                        //写入数据组
                        List<Double> value = new ArrayList<>();
                        List<PraphData> value2 = new ArrayList<>();
                        for (InitGrapData initTimingGraphDatum : initTimingGraphData) {
                            //遍历之前查的所有数据，然后判断如果SID相等就封装到目标中
                            PraphData praphData1 = new PraphData();
                            if (initTimingGraphDatum.getSensorID().equals(sensor)) {
                                value.add(initTimingGraphDatum.getValue());
                                praphData1.setValue(initTimingGraphDatum.getValue());
                                long l = initTimingGraphDatum.getDataTime().longValue();
                                Date date2 = new Date(l - baseLongValue);
                                SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                String time3 = simpleDateFormat2.format(date2);
                                praphData1.setTime(time3);
                                value2.add(praphData1);
                            }
                        }
                        //按照时间步长固定取值的大小
                        if (value.size() < selfMakeTotalTimes) {
                            int gapTimes = selfMakeTotalTimes - value.size();
                            for (int i = 0; i < gapTimes; i++) {
                                value.add(null);
                                PraphData praphDataForFillGap = new PraphData();
                                praphDataForFillGap.setTime("null" + i);
                                praphDataForFillGap.setValue(null);
                                value2.add(praphDataForFillGap);
                            }
                        }
                        //整体固定结束以后还有一步，就是把几个固定的索引的value2的time改一下，总之就是要分成8份
                        // （从0点到第二天的0点，中间要显8个其他的点，即3、6、9、12、15、18等，所以是一天分成8份）
                        int numberOfCopies = (selfMakeTotalTimes - 1) / 2 / 8;
                        //这样分了以后，第一个索引设置为“昨天”，间隔9个设置为对应的时间点，简单说就是分成了16份，写一个16次的循环
                        for (int i = 0; i < 16; i++) {
                            if (i < 8) {
                                value2.get(i * numberOfCopies).setTime("昨天" + i * 3 + ":00");
                            } else {
                                value2.get(i * numberOfCopies).setTime("今天" + (i - 8) * 3 + ":00");
                            }
                        }
                        value2.get(selfMakeTotalTimes - 1).setTime("明天");

                        //value2改完以后就可以在下面的语句中存入了
                        pointData1.setValue(value);
                        pointData1.setValue2(value2);
                        pointData.add(pointData1);
                    }
                    siteData1.setValue(pointData);
                    siteDataList.add(siteData1);
                }
                planeData1.setChildren(siteDataList);
                allGraphData.add(planeData1);
            }
            return allGraphData;
        }
       return allGraphData;

    }

    @Override
    public List getAll3DGraphDataByToken() {
        //查询存储的数据的最新时间，这一步是必要的，因为有可能时间不是最新的
        BigInteger dataTime = dataMapper2.getBaseTime();
        long longValue = dataTime.longValue();
        //倒推标准时间所需要减去的时间
        long baseLongValue = 404467200000L;
        Date date = new Date(longValue - baseLongValue);
        //获取年
        SimpleDateFormat sqlServerYear = new SimpleDateFormat("yyyy");
        int sqlYear= Integer.parseInt(sqlServerYear.format(date));
        //获取月
        SimpleDateFormat sqlServerMonth = new SimpleDateFormat("MM");
        int sqlMonth= Integer.parseInt(sqlServerMonth.format(date));
        //获取日
        SimpleDateFormat sqlServerDay = new SimpleDateFormat("dd");
        int sqlDay= Integer.parseInt(sqlServerDay.format(date));
        //获取小时
        SimpleDateFormat sqlServerHour = new SimpleDateFormat("HH");
        int sqlHour= Integer.parseInt(sqlServerHour.format(date));
        //获取分钟
        SimpleDateFormat sqlServerMinute = new SimpleDateFormat("mm");
        int sqlMinute= Integer.parseInt(sqlServerMinute.format(date));
        //获取本地时间
        Calendar cal=Calendar.getInstance();
        int y=cal.get(Calendar.YEAR);   //获取年
        int m=cal.get(Calendar.MONTH);   //获取月，需要加1才正常
        int d=cal.get(Calendar.DATE);   //获取日
        int h=cal.get(Calendar.HOUR_OF_DAY);   //获取小时
        int mi=cal.get(Calendar.MINUTE);   //获取分钟
        //获取传感器的个数
        Integer basePointsNumber = dataMapper2.getBasePointsNumber();

        //根据时间获取昨天到现在的数据，所以要计算现在的时间并且传过去
        //同样的，这里需要添加一个判断，如果时间对上了就用本地最新时间，如果没有对上，就以数据库的最新时间为准
        if (sqlYear==y&&Math.abs(d-sqlDay)<2&&sqlMonth==m+1) {
            Date currentDate = new Date();
            LocalDateTime midnight = LocalDateTime.ofInstant(currentDate.toInstant(),
                    ZoneId.systemDefault()).plusDays(0).withHour(0).withMinute(0)
                    .withSecond(0).withNano(0);
            long time2 = midnight.toInstant(ZoneOffset.of("+8")).toEpochMilli();
            //倒推标准时间所需要减去的时间
            //数据库的标准时间
            long realTime = baseLongValue + time2;
            List<InitGrapData> initTimingGraphData = dataMapper2.getTimingInitGraphData(realTime);



            List all3DGraphData1 = new ArrayList<>();

            //这里将查询的数据抽取转换成绘图的最简单的308条数据形式的方法抽取成了方法
            tansferDataToGraphData(basePointsNumber, initTimingGraphData, all3DGraphData1);

            return all3DGraphData1;
        }else {
           //时间没有对应上，就使用数据库的时间作为基准时间
            LocalDateTime midnight = LocalDateTime.ofInstant(date.toInstant(),
                    ZoneId.systemDefault()).plusDays(0).withHour(0).withMinute(0)
                    .withSecond(0).withNano(0);
            long time2 = midnight.toInstant(ZoneOffset.of("+8")).toEpochMilli();
            //倒推标准时间所需要减去的时间
            //数据库的标准时间
            long realTime = baseLongValue + time2;
            List<InitGrapData> initTimingGraphData = dataMapper2.getTimingInitGraphData(realTime);

            List all3DGraphData1 = new ArrayList<>();

            //这里将查询的数据抽取转换成绘图的最简单的308条数据形式的方法抽取成了方法
            tansferDataToGraphData(basePointsNumber, initTimingGraphData, all3DGraphData1);

            return all3DGraphData1;
        }

    }

    @Override
    @Transactional(transactionManager = "test1TransactionManager")
    public List getAllPredictDataByToken() {
        //根据时间来判断是否需要创造就先创造，如果有数据就不用创造
        Calendar cal=Calendar.getInstance();
        int y=cal.get(Calendar.YEAR);   //获取年
        int m=cal.get(Calendar.MONTH);   //获取月，需要加1才正常
        int d=cal.get(Calendar.DATE);   //获取日
        int h=cal.get(Calendar.HOUR_OF_DAY);   //获取小时
        int mi=cal.get(Calendar.MINUTE);   //获取分钟
        //获取预测表中的最新时间
        AllPredictData allPredictData=dataMapper1.getPredictTime();
        //查询存储的数据的最新时间
        BigInteger dataTime = dataMapper2.getBaseTime();

        long longValue = dataTime.longValue();
        //倒推标准时间所需要减去的时间
        long baseLongValue = 404467200000L;
        Date date = new Date(longValue - baseLongValue);
        //获取年
        SimpleDateFormat sqlServerYear = new SimpleDateFormat("yyyy");
        int sqlYear= Integer.parseInt(sqlServerYear.format(date));
        //获取月
        SimpleDateFormat sqlServerMonth = new SimpleDateFormat("MM");
        int sqlMonth= Integer.parseInt(sqlServerMonth.format(date));
        //获取日
        SimpleDateFormat sqlServerDay = new SimpleDateFormat("dd");
        int sqlDay= Integer.parseInt(sqlServerDay.format(date));
        //获取小时
        SimpleDateFormat sqlServerHour = new SimpleDateFormat("HH");
        int sqlHour= Integer.parseInt(sqlServerHour.format(date));
        //获取分钟
        SimpleDateFormat sqlServerMinute = new SimpleDateFormat("mm");
        int sqlMinute= Integer.parseInt(sqlServerMinute.format(date));
        //获取传感器的个数
        Integer basePointsNumber = dataMapper2.getBasePointsNumber();

        //以下的流程是系统时间和最新时间间隔不超过1天才会进行的操作，如果时间间隔超过了1天直接就以查的最新时间作为基准时间
        if (sqlYear==y&&Math.abs(d-sqlDay)<2&&sqlMonth==m+1) {
            //开始判断，如果时间对上了就直接查询处理
            if(y == allPredictData.getTimeYear()&&m+1==allPredictData.getTimeMonth()&&d==allPredictData.getTimeDay()){
                //如果时间对上了就直接查询后返回
                List<AllPredictData> allPredictDataList =dataMapper1.getPredictValue(y,m+1,d);
                //拿到数据以后就是遍历处理成简单数组的形式传给前端
                List allPredictGraphData = new ArrayList<>();
                transferPredictDataToGraphPredictData(basePointsNumber, allPredictDataList, allPredictGraphData);
                return allPredictGraphData;
            }else {
                //如果时间没有对上就开始往数据库中写数据，思路就是先获取今天已经有的数据，然后进行处理，没有的就自行补充
                Date currentDate = new Date();
                LocalDateTime midnight = LocalDateTime.ofInstant(currentDate.toInstant(),
                        ZoneId.systemDefault()).plusDays(-1).withHour(0).withMinute(0)
                        .withSecond(0).withNano(0);
                long time2 = midnight.toInstant(ZoneOffset.of("+8")).toEpochMilli();
                //倒推标准时间所需要减去的时间，数据库的标准时间
                long realTime = baseLongValue + time2;
                List<InitGrapData> initTimingGraphData = dataMapper2.getTimingInitGraphData(realTime);
                //每天固定的数据的个数为72个


                List<AllPredictData> allPredictDataList=new ArrayList<>();
                for (Integer i = 0; i < basePointsNumber; i++) {

                    int turnTimes=1;

                    for (InitGrapData initTimingGraphDatum : initTimingGraphData) {
                        if (allPredictDataList.size()<72*(i+1)) {
                            AllPredictData allPredictData1 = new AllPredictData();
                            if (initTimingGraphDatum.getSensorID().equals(i+1)) {
                                allPredictData1.setSensorID(i+1);
                                allPredictData1.setCreateTime(currentDate);
                                allPredictData1.setPredictValue(initTimingGraphDatum.getValue()+ turnTimes * 0.01 * Math.random()*Math.pow(-1,(int)(Math.random()*100)));
                                allPredictData1.setThisTurnId(turnTimes);
                                allPredictData1.setTimeMinute(mi);
                                allPredictData1.setTimeHour(h);
                                allPredictData1.setTimeDay(d);
                                allPredictData1.setTimeYear(y);
                                allPredictData1.setTimeMonth(m+1);
                                allPredictDataList.add(allPredictData1);
                                turnTimes ++;
                            }}

                    }
                }
                //将数据写入到数据库
                dataMapper1.createPredictValue(allPredictDataList);
                //写完以后就会说传输
                List<AllPredictData> allPredictDataList1 =dataMapper1.getPredictValue(y,m+1,d);
                //拿到数据以后就是遍历处理成简单数组的形式传给前端
                List allPredictGraphData = new ArrayList<>();
                //这里就是转换的思路
                transferPredictDataToGraphPredictData(basePointsNumber, allPredictDataList1, allPredictGraphData);
                return allPredictGraphData;
            }
        }else {
            //如果走到此判断说明最新数据出了问题，那么就只能按照数据库中的最新时间来了
            //此时需要注意，这个最新时间比如是5.7，那么预测数据只能到5.7 为止。
            //开始判断，如果数据库时间对上了预测数据库中的时间就直接查询处理
            if(sqlYear == allPredictData.getTimeYear() && sqlMonth==allPredictData.getTimeMonth()&&sqlDay==allPredictData.getTimeDay()){
                //如果时间对上了就直接查询后返回
                List<AllPredictData> allPredictDataList =dataMapper1.getPredictValue(sqlYear,sqlMonth,sqlDay);
                //拿到数据以后就是遍历处理成简单数组的形式传给前端
                List allPredictGraphData = new ArrayList<>();
                transferPredictDataToGraphPredictData(basePointsNumber, allPredictDataList, allPredictGraphData);
                return allPredictGraphData;
            }else {
                //如果时间没有对上就开始往数据库中写数据，思路就是先获取今天已经有的数据，然后进行处理，没有的就自行补充

                LocalDateTime midnight = LocalDateTime.ofInstant(date.toInstant(),
                        ZoneId.systemDefault()).plusDays(-1).withHour(0).withMinute(0)
                        .withSecond(0).withNano(0);
                long time2 = midnight.toInstant(ZoneOffset.of("+8")).toEpochMilli();
                //倒推标准时间所需要减去的时间，数据库的标准时间
                long realTime = baseLongValue + time2;
                List<InitGrapData> initTimingGraphData = dataMapper2.getTimingInitGraphData(realTime);
                //每天固定的数据的个数为72个


                List<AllPredictData> allPredictDataList=new ArrayList<>();
                for (Integer i = 0; i < basePointsNumber; i++) {

                    int turnTimes=1;

                    for (InitGrapData initTimingGraphDatum : initTimingGraphData) {
                        if (allPredictDataList.size()<72*(i+1)) {
                            AllPredictData allPredictData1 = new AllPredictData();
                            if (initTimingGraphDatum.getSensorID().equals(i+1)) {
                                allPredictData1.setSensorID(i+1);
                                allPredictData1.setCreateTime(date);
                                allPredictData1.setPredictValue(initTimingGraphDatum.getValue()+ turnTimes * 0.01 * Math.random()*Math.pow(-1,(int)(Math.random()*100)));
                                allPredictData1.setThisTurnId(turnTimes);
                                allPredictData1.setTimeMinute(sqlMinute);
                                allPredictData1.setTimeHour(sqlHour);
                                allPredictData1.setTimeDay(sqlDay);
                                allPredictData1.setTimeYear(sqlYear);
                                allPredictData1.setTimeMonth(sqlMonth);
                                allPredictDataList.add(allPredictData1);
                                turnTimes ++;
                            }}
                    }
                }
                //将数据写入到数据库
                dataMapper1.createPredictValue(allPredictDataList);
                //写完以后就会说传输
                List<AllPredictData> allPredictDataList1 =dataMapper1.getPredictValue(sqlYear,sqlMonth,sqlDay);
                //拿到数据以后就是遍历处理成简单数组的形式传给前端
                List allPredictGraphData = new ArrayList<>();
                //这里就是转换的思路
                transferPredictDataToGraphPredictData(basePointsNumber, allPredictDataList1, allPredictGraphData);
                return allPredictGraphData;
            }


        }

    }

    private void transferPredictDataToGraphPredictData(Integer basePointsNumber, List<AllPredictData> allPredictDataList, List allPredictGraphData) {
        for (Integer i = 0; i < basePointsNumber; i++) {
            ArrayList<Double> doubles = new ArrayList<>();
            for (AllPredictData predictData : allPredictDataList) {
                if (predictData.getSensorID().equals(i+1)) {
                    doubles.add(predictData.getPredictValue());
                }
            }
            allPredictGraphData.add(doubles);
        }
    }

    private void tansferDataToGraphData(Integer basePointsNumber, List<InitGrapData> initTimingGraphData, List all3DGraphData1) {
        for (Integer i = 0; i < basePointsNumber; i++) {
            ArrayList<Double> doubles = new ArrayList<>();
            for (InitGrapData initTimingGraphDatum : initTimingGraphData) {
                if (initTimingGraphDatum.getSensorID().equals(i+1)) {
                    doubles.add(initTimingGraphDatum.getValue());
                }
            }

            all3DGraphData1.add(doubles);
        }
    }


    private void judgeStype(AllCurrentData allCurrentDatum, TableData tableData) {
        switch (allCurrentDatum.getStype()) {
            case 1:
                tableData.setStype("应力");
                break;
            case 2:
                tableData.setStype("位移");
                break;
            case 3:
                tableData.setStype("挠度");
                break;
            case 4:
                tableData.setStype("温度");
                break;
            case 5:
                tableData.setStype("应变");
                break;
            default:
                tableData.setStype("其他");
        }
    }
}
